package com.qf.day14;

import java.io.*;
import java.util.*;

/**
 * 1. 把文本文件中的IP地址进行去重，然后打印出来
 * 2. 统计一个文本文件中IP地址的出现的次数（IP地址格式为192.168.10.39，每行只存放一个IP地址）
 * 3. 查询出ip地址出现次数最多的是哪个IP
 * 4. 查询ip访问次数为前3名的ip是什么，和他们的访问次数 （对map中的键值对按照value进行排序）
 */
public class HashmapDemo {

    public static void main(String[] args) throws FileNotFoundException {

        String d = "D:\\IP.txt";
        List<String> data = loadData(d);
        HashMap<String, Integer> map = new HashMap<>();
        for (String ip : data) {
            Integer oldValue = map.get(ip);
            map.put(ip,oldValue==null?1:oldValue+1);
        }
        System.out.println(map);

        // 对map中的entry对象，按照value进行排序
        Set<Map.Entry<String, Integer>> entries = map.entrySet();

        // 对set集合进行排序
        // 可以使用TreeSet进行排序
        // 如何指定Treeset中的元素的大小关系呢？ 提供一个比较器对象 ，按照Entry的value部分进行大小比较 ，倒叙
        TreeSet<Map.Entry<String, Integer>> treeSet = new TreeSet<>(new Comparator<Map.Entry<String, Integer>>() {
            @Override
            public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
                return o2.getValue()-o1.getValue();
            }
        });

        treeSet.addAll(entries);

        // 展示treeset中的前三个元素
        int count = 0;
        for (Map.Entry<String, Integer> entry : treeSet) {
            System.out.println(entry.getKey()+":"+entry.getValue());
            count++;
            if (count==3){
                return;
            }
        }


    }

    private static void q03() throws FileNotFoundException {
        // 在第二步map的基础上，只要找到value最大的map中的entry（key，value），再获取对于的key
        String d = "D:\\IP.txt";
        List<String> data = loadData(d);

        // 构造map key是ip地址，value是次数
        HashMap<String, Integer> map = new HashMap<>();
        for (String ip : data) {
            Integer oldValue = map.get(ip);
            map.put(ip,oldValue==null?1:oldValue+1);
        }
        // 遍历map中的所有entry对象，寻找value最大的那个
        Set<Map.Entry<String, Integer>> entries = map.entrySet();
        // 定义一个变量，代表value最大的entry对象
        Map.Entry<String, Integer> max = null;
        for (Map.Entry<String, Integer> entry : entries) {
            if (max==null){
                // 第一遍历时，把当前的entry对象直接作为最大值即可
                max=entry;
            }else {
                // 不是第一次遍历，需要比较 max和当前entry的value的大小
                if (max.getValue()<entry.getValue()) {
                    max = entry;
                }
            }
        }
        System.out.println("访问次数最多的ip为:"+max);
    }

    // 2. 统计一个文本文件中IP地址的出现的次数（IP地址格式为192.168.10.39，每行只存放一个IP地址）
    private static void q02() throws FileNotFoundException {
        //文件地址
        String d = "D:\\IP.txt";
        File file = new File(d);
        Scanner scanner = new Scanner(file);
        //2.统计一个文本文件中IP地址的出现的次数(IP地址格式为192.168.10.39，每行只存放一个IP地址)
        HashMap<String, Integer> map = new HashMap<>();
        while (scanner.hasNextLine()) {
            String s = scanner.nextLine();
            Integer oldValue = map.get(s);
            map.put(s,oldValue==null?1:oldValue+1);
        }
        System.out.println(map);
    }

    /**
     * 1. 把文本文件中的IP地址进行去重，然后打印出来
     *
     * @throws FileNotFoundException
     */
    private static void q01() throws FileNotFoundException {
        String filepath = "D:\\IP.txt";
        List<String> data = loadData(filepath);
        System.out.println(data);
        // 对data中的数据进行去重
        HashSet<String> set = new HashSet<>(data);
        System.out.println(set);
    }

    private static void wanghaibo() {
        String filepath = "D:\\IP.txt";
        // 可以去掉重复元素
        Set<String> uniqueIps = new HashSet<>();
        // 创建了一个可以按行读取文本文件内容的对象 BufferedReader
        try (BufferedReader reader = new BufferedReader(new FileReader(filepath))) {
            String line; // 局部变量line，用来存放每一行的数据
            while ((line = reader.readLine()) != null) {
                // 去除行首尾的空格，并将连续的空格替换为一个空格
                String trimmedLine = line.trim().replaceAll("\\s+", " ");
                // 假设每行只有一个IP地址，直接添加到集合中
                if (!trimmedLine.isEmpty() && isValidIp(trimmedLine.split(" ")[0])) {
                    uniqueIps.add(trimmedLine.split(" ")[0]);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 打印去重后的IP地址
        for (String ip : uniqueIps) {
            System.out.println(ip);
        }
    }

    /**
     * 把数据从文本文件中读取出来，放入List
     *
     * @param filepath
     * @return
     */
    public static List<String> loadData(String filepath) throws FileNotFoundException {

        // 创建扫描器对象用来扫描文件
        Scanner scanner = new Scanner(new File(filepath));
        // 创建List对象
        ArrayList<String> result = new ArrayList<>();
        // 逐行扫描文件
        String line = "";
        while (scanner.hasNextLine()) {
            line = scanner.nextLine();
            result.add(line);
        }
        // 关闭扫描器对象
        scanner.close();
        return result;

    }

    // 检查字符串是否为有效的IPv4地址
    private static boolean isValidIp(String ip) {
        String IPADDRESS_PATTERN =
                "^([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\." +
                        "([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\." +
                        "([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\." +
                        "([01]?\\d\\d?|2[0-4]\\d|25[0-5])$";

        return ip.matches(IPADDRESS_PATTERN);
    }
}
